import request from "@/utils/request"
/**
 * 获取用途分片数据
 * @param {Object} params
 * @param {Number} params.id 公司id
 * @param {String} params.sub_category 要查询的用途
 * @param {Number} params.start_time 开始时间
 * @param {Number} params.end_time 结束时间
 * @param {Number} params.interval 时间间隔
 * @param {Number} params.type 表计类型
 * @returns {Promise}
 */

export function getSubCategoryReportApi(params) {
    return request.get('/report/subcategory', { params });
}

import dayjs from 'dayjs';

/**
 * 获取所有用途总共的数据
 * @param {Object} params
 * @param {Number} params.id 公司id
 * @param {Number|String} params.start_time 开始时间（13位时间戳或日期字符串）
 * @param {Number|String} params.end_time 结束时间（13位时间戳或日期字符串）
 * @param {Number} params.interval 时间间隔
 * @param {Number} params.type 表计类型
 */
export function getAllSubCategoryReportApi(params) {
    // 基础参数验证
    if (!params?.id) {
        throw new Error('公司ID不能为空');
    }

    if (!params?.start_time || !params?.end_time) {
        throw new Error('开始时间和结束时间不能为空');
    }

    // 转换时间为13位时间戳
    const normalizedParams = {
        ...params,
        start_time: convertToTimestamp(params.start_time),
        end_time: convertToTimestamp(params.end_time)
    };

    // 如果没有interval，需要特殊处理
    if (!normalizedParams.interval) {
        // 检查时间跨度是否超过3个月
        const timeSpanMonths = calculateTimeSpanInMonths(normalizedParams.start_time, normalizedParams.end_time);

        if (timeSpanMonths > 3) {
            // 超过3个月，按月分批获取数据
            return getSubCategoryDataByMonths(normalizedParams);
        } else {
            // 3个月内，按天获取然后聚合
            return getSubCategoryDataByDays(normalizedParams);
        }
    }

    // 有interval时，直接请求
    return request.get('/report/subcategory/total', {
        params: normalizedParams
    }).then(response => {
        // 验证并过滤数据
        if (!response?.aggregated_data || !Array.isArray(response.aggregated_data)) {
            throw new Error('数据格式错误');
        }

        // 过滤用量为0的用途
        response.aggregated_data = response.aggregated_data.map(dayData =>
            filterZeroUsageSubCategories(dayData)
        );

        return response;
    }).catch(error => {

        throw error;
    });
}

/**
 * 转换时间为13位时间戳
 * @param {Number|String} time - 时间（可以是时间戳、日期字符串等）
 * @returns {Number} 13位时间戳
 */
function convertToTimestamp(time) {
    if (!time) return null;

    // 如果已经是13位时间戳，直接返回
    if (typeof time === 'number' && time.toString().length === 13) {
        return time;
    }

    // 如果是10位时间戳，转换为13位
    if (typeof time === 'number' && time.toString().length === 10) {
        return time * 1000;
    }

    // 使用dayjs解析并转换为13位时间戳
    return dayjs(time).valueOf();
}

/**
 * 计算时间跨度（月数）
 * @param {Number} startTime - 开始时间（13位时间戳）
 * @param {Number} endTime - 结束时间（13位时间戳）
 * @returns {Number} 月数差
 */
function calculateTimeSpanInMonths(startTime, endTime) {
    const start = dayjs(startTime);
    const end = dayjs(endTime);

    const yearDiff = end.year() - start.year();
    const monthDiff = end.month() - start.month();

    return yearDiff * 12 + monthDiff + 1; // +1 因为包含起始月
}

/**
 * 生成月份时间段
 * @param {Number} startTime - 开始时间（13位时间戳）
 * @param {Number} endTime - 结束时间（13位时间戳）
 * @returns {Array} 月份时间段数组
 */
function generateMonthlyPeriods(startTime, endTime) {
    const periods = [];
    const start = dayjs(startTime);
    const end = dayjs(endTime);

    let current = start.startOf('month'); // 当月第一天

    while (current.isBefore(end) || current.isSame(end, 'month')) {
        const periodStart = current;
        const periodEnd = current.endOf('month'); // 当月最后一天

        // 确保不超过原始结束时间
        const actualEnd = periodEnd.isAfter(end) ? end : periodEnd;

        periods.push({
            start_time: periodStart.valueOf(), // 13位时间戳
            end_time: actualEnd.valueOf()      // 13位时间戳
        });

        // 移动到下一个月
        current = current.add(1, 'month').startOf('month');
    }

    return periods;
}

/**
 * 按月获取用途数据
 * @param {Object} params - 原始参数
 * @returns {Promise} 聚合后的响应
 */
async function getSubCategoryDataByMonths(params) {
    try {
        const monthlyPeriods = generateMonthlyPeriods(params.start_time, params.end_time);
        const monthlyPromises = monthlyPeriods.map(period =>
            request.get('/report/subcategory/total', {
                params: {
                    ...params,
                    start_time: period.start_time,
                    end_time: period.end_time,
                    interval: 'day'
                }
            })
        );

        const monthlyResponses = await Promise.all(monthlyPromises);

        // 合并所有月份的数据
        const allDailyData = [];
        monthlyResponses.forEach(response => {
            if (response?.aggregated_data) {
                allDailyData.push(...response.aggregated_data);
            }
        });

        // 聚合数据
        const aggregatedData = aggregateSubCategoryDailyData(allDailyData, params);

        return {
            ...monthlyResponses[0], // 使用第一个响应的基本信息
            aggregated_data: [aggregatedData]
        };

    } catch (error) {

        throw error;
    }
}

/**
 * 按天获取用途数据
 * @param {Object} params - 原始参数
 * @returns {Promise} 聚合后的响应
 */
function getSubCategoryDataByDays(params) {
    const requestParams = { ...params, interval: 'day' };

    return request.get('/report/subcategory/total', {
        params: requestParams
    }).then(response => {
        // 验证响应数据
        if (!response?.aggregated_data || !Array.isArray(response.aggregated_data)) {
            throw new Error('数据格式错误');
        }

        // 聚合每天的数据
        const aggregatedData = aggregateSubCategoryDailyData(response.aggregated_data, params);

        return {
            ...response,
            aggregated_data: [aggregatedData]
        };
    }).catch(error => {

        throw error;
    });
}

/**
 * 过滤用量为0的用途和表计
 * @param {Array} dayData - 单天的用途数据
 * @returns {Array} 过滤后的数据
 */
function filterZeroUsageSubCategories(dayData) {
    return dayData.map(subcategoryItem => {
        // 过滤掉Used为0的表计
        const filteredUsage = subcategoryItem.usage.filter(meter =>
            parseFloat(meter.Used) > 0
        );

        return {
            ...subcategoryItem,
            usage: filteredUsage
        };
    }).filter(subcategoryItem =>
        // 只保留还有表计数据的用途
        subcategoryItem.usage.length > 0
    );
}

/**
 * 聚合每天的用途数据
 * @param {Array} dailyData - 按天分组的数据
 * @param {Object} originalParams - 原始请求参数
 * @returns {Array} 聚合后的数据
 */
function aggregateSubCategoryDailyData(dailyData, originalParams) {
    if (!dailyData.length) return [];

    // 用于存储每个subcategory的聚合数据
    const subcategoryMap = new Map();

    // 遍历每天的数据
    dailyData.forEach(dayData => {
        dayData.forEach(subcategoryItem => {
            const subcategoryName = subcategoryItem.subcategory;

            // 过滤并处理表计数据
            const validMeterData = [];
            let totalUsage = 0;
            let combinedErrors = [];

            if (Array.isArray(subcategoryItem.usage)) {
                subcategoryItem.usage.forEach(meterData => {
                    const used = parseFloat(meterData.Used) || 0;

                    // 跳过用量为0的表计
                    if (used === 0) return;

                    totalUsage += used;

                    // 收集错误信息
                    if (meterData.error) {
                        combinedErrors.push(`表计${meterData.meter_id}: ${meterData.error}`);
                    }

                    // 保存有效的表计数据
                    validMeterData.push({
                        meter_id: meterData.meter_id,
                        usage: used,
                        error: meterData.error || ''
                    });
                });
            }

            // 跳过没有有效表计数据的用途
            if (validMeterData.length === 0) return;

            if (subcategoryMap.has(subcategoryName)) {
                // 累加用量和合并表计数据
                const existingItem = subcategoryMap.get(subcategoryName);
                existingItem.totalUsage += totalUsage;

                // 合并表计数据
                validMeterData.forEach(newMeterData => {
                    const existingMeter = existingItem.meterData.find(m => m.meter_id === newMeterData.meter_id);
                    if (existingMeter) {
                        existingMeter.usage += newMeterData.usage;
                        // 合并错误信息
                        if (newMeterData.error && !existingMeter.error) {
                            existingMeter.error = newMeterData.error;
                        } else if (newMeterData.error && existingMeter.error) {
                            existingMeter.error += '; ' + newMeterData.error;
                        }
                    } else {
                        existingItem.meterData.push(newMeterData);
                    }
                });

                // 合并用途级别的错误信息
                if (combinedErrors.length > 0) {
                    if (!existingItem.error) {
                        existingItem.error = combinedErrors.join('; ');
                    } else {
                        existingItem.error += '; ' + combinedErrors.join('; ');
                    }
                }

                // 合并subcategory级别的错误
                if (subcategoryItem.error && !existingItem.subcategoryError) {
                    existingItem.subcategoryError = subcategoryItem.error;
                } else if (subcategoryItem.error && existingItem.subcategoryError) {
                    existingItem.subcategoryError += '; ' + subcategoryItem.error;
                }
            } else {
                // 创建新的聚合项
                subcategoryMap.set(subcategoryName, {
                    subcategory: subcategoryName,
                    totalUsage: totalUsage,
                    meterData: [...validMeterData],
                    error: combinedErrors.join('; '),
                    subcategoryError: subcategoryItem.error || ''
                });
            }
        });
    });

    // 转换为最终格式，再次确保过滤掉用量为0的数据
    return Array.from(subcategoryMap.values())
        .filter(item => item.totalUsage > 0) // 确保总用量大于0
        .map(item => ({
            subcategory: item.subcategory,
            usage: item.meterData
                .filter(meter => meter.usage > 0) // 再次过滤用量为0的表计
                .map(meter => ({
                    meter_id: meter.meter_id,
                    Start: "聚合数据",
                    StartTime: dayjs(originalParams.start_time).format('YYYY-MM-DDTHH:mm:ssZ'),
                    Used: meter.usage.toString(),
                    End: "聚合数据",
                    EndTime: dayjs(originalParams.end_time).format('YYYY-MM-DDTHH:mm:ssZ'),
                    error: meter.error
                })),
            error: item.subcategoryError,
            summary: {
                totalUsage: item.totalUsage,
                meterCount: item.meterData.filter(m => m.usage > 0).length
            }
        }))
        .filter(item => item.usage.length > 0) // 确保还有有效的表计数据
        .sort((a, b) => a.subcategory.localeCompare(b.subcategory));
}